{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium==0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 07. N-Step Learning\n",
    "\n",
    "[R. S. Sutton, \"Learning to predict by the methods of temporal differences.\" Machine learning, 3(1):9–44, 1988.](http://incompleteideas.net/papers/sutton-88-with-erratum.pdf)\n",
    "\n",
    "Q-learning accumulates a single reward and then uses the greedy action at the next step to bootstrap. Alternatively, forward-view multi-step targets can be used (Sutton 1988). We call it Truncated N-Step Return\n",
    "from a given state $S_t$. It is defined as,\n",
    "\n",
    "$$\n",
    "R^{(n)}_t = \\sum_{k=0}^{n-1} \\gamma_t^{(k)} R_{t+k+1}.\n",
    "$$\n",
    "\n",
    "A multi-step variant of DQN is then defined by minimizing the alternative loss,\n",
    "\n",
    "$$\n",
    "(R^{(n)}_t + \\gamma^{(n)}_t \\max_{a'} q_{\\theta}^{-}\n",
    "(S_{t+n}, a')\n",
    "- q_{\\theta}(S_t, A_t))^2.\n",
    "$$\n",
    "\n",
    "Multi-step targets with suitably tuned $n$ often lead to faster learning (Sutton and Barto 1998)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/codespace/.local/lib/python3.10/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from collections import deque\n",
    "from typing import Deque, Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer for N-step learning\n",
    "\n",
    "There are a little bit changes in Replay buffer for N-step learning. First, we use `deque` to store the most recent n-step transitions.\n",
    "\n",
    "```python\n",
    "    self.n_step_buffer = deque(maxlen=n_step)\n",
    "```\n",
    "\n",
    "You can see it doesn't actually store a transition in the buffer, unless `n_step_buffer` is full.\n",
    "\n",
    "```\n",
    "    # in store method\n",
    "    if len(self.n_step_buffer) < self.n_step:\n",
    "        return ()\n",
    "```\n",
    "\n",
    "When the length of `n_step_buffer` becomes equal to N, it eventually stores the N-step transition, which is calculated by `_get_n_step_info` method.\n",
    "\n",
    "(Please see *01.dqn.ipynb* for detailed description of the basic replay buffer.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        obs_dim: int, \n",
    "        size: int, \n",
    "        batch_size: int = 32, \n",
    "        n_step: int = 3, \n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "        \n",
    "        # for N-step Learning\n",
    "        self.n_step_buffer = deque(maxlen=n_step)\n",
    "        self.n_step = n_step\n",
    "        self.gamma = gamma\n",
    "\n",
    "    def store(\n",
    "        self, \n",
    "        obs: np.ndarray, \n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool\n",
    "    ) -> Tuple[np.ndarray, np.ndarray, float, np.ndarray, bool]:\n",
    "        transition = (obs, act, rew, next_obs, done)\n",
    "        self.n_step_buffer.append(transition)\n",
    "\n",
    "        # single step transition is not ready\n",
    "        if len(self.n_step_buffer) < self.n_step:\n",
    "            return ()\n",
    "        \n",
    "        # make a n-step transition\n",
    "        rew, next_obs, done = self._get_n_step_info(\n",
    "            self.n_step_buffer, self.gamma\n",
    "        )\n",
    "        obs, act = self.n_step_buffer[0][:2]\n",
    "        \n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "        \n",
    "        return self.n_step_buffer[0]\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        indices = np.random.choice(\n",
    "            self.size, size=self.batch_size, replace=False\n",
    "        )\n",
    "\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "            # for N-step Learning\n",
    "            indices=indices,\n",
    "        )\n",
    "    \n",
    "    def sample_batch_from_idxs(\n",
    "        self, indices: np.ndarray\n",
    "    ) -> Dict[str, np.ndarray]:\n",
    "        # for N-step Learning\n",
    "        return dict(\n",
    "            obs=self.obs_buf[indices],\n",
    "            next_obs=self.next_obs_buf[indices],\n",
    "            acts=self.acts_buf[indices],\n",
    "            rews=self.rews_buf[indices],\n",
    "            done=self.done_buf[indices],\n",
    "        )\n",
    "    \n",
    "    def _get_n_step_info(\n",
    "        self, n_step_buffer: Deque, gamma: float\n",
    "    ) -> Tuple[np.int64, np.ndarray, bool]:\n",
    "        \"\"\"Return n step rew, next_obs, and done.\"\"\"\n",
    "        # info of the last transition\n",
    "        rew, next_obs, done = n_step_buffer[-1][-3:]\n",
    "\n",
    "        for transition in reversed(list(n_step_buffer)[:-1]):\n",
    "            r, n_o, d = transition[-3:]\n",
    "\n",
    "            rew = r + gamma * rew * (1 - d)\n",
    "            next_obs, done = (n_o, d) if d else (next_obs, done)\n",
    "\n",
    "        return rew, next_obs, done\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent + N-step learning Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use two buffers: `memory` and `memory_n` for 1-step transitions and n-step transitions respectively. It guarantees that any paired 1-step and n-step transitions have the same indices (See `step` method for more details). Due to the reason, we can sample pairs of transitions from the two buffers once we have indices for samples.\n",
    "\n",
    "```python\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        ...\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        ...\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            ...\n",
    "```\n",
    "\n",
    "One thing to note that  we are gonna combine 1-step loss and n-step loss so as to control high-variance / high-bias trade-off.\n",
    "\n",
    "(Search the comments with *N-step Leaning* to see any difference from DQN.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "        use_n_step (bool): whether to use n_step memory\n",
    "        n_step (int): step number to calculate n-step td error\n",
    "        memory_n (ReplayBuffer): n-step replay buffer\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "        # N-step Learning\n",
    "        n_step: int = 3,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "            n_step (int): step number to calculate n-step td error\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # memory for 1-step Learning\n",
    "        self.memory = ReplayBuffer(\n",
    "            obs_dim, memory_size, batch_size, n_step=1, gamma=gamma\n",
    "        )\n",
    "        \n",
    "        # memory for N-step Learning\n",
    "        self.use_n_step = True if n_step > 1 else False\n",
    "        if self.use_n_step:\n",
    "            self.n_step = n_step\n",
    "            self.memory_n = ReplayBuffer(\n",
    "                obs_dim, memory_size, batch_size, n_step=n_step, gamma=gamma\n",
    "            )\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            \n",
    "            # N-step transition\n",
    "            if self.use_n_step:\n",
    "                one_step_transition = self.memory_n.store(*self.transition)\n",
    "            # 1-step transition\n",
    "            else:\n",
    "                one_step_transition = self.transition\n",
    "\n",
    "            # add a single step transition\n",
    "            if one_step_transition:\n",
    "                self.memory.store(*one_step_transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "        indices = samples[\"indices\"]\n",
    "        loss = self._compute_dqn_loss(samples, self.gamma)\n",
    "        \n",
    "        # N-step Learning loss\n",
    "        # we are gonna combine 1-step loss and n-step loss so as to\n",
    "        # prevent high-variance.\n",
    "        if self.use_n_step:\n",
    "            samples = self.memory_n.sample_batch_from_idxs(indices)\n",
    "            gamma = self.gamma ** self.n_step\n",
    "            n_loss = self._compute_dqn_loss(samples, gamma)\n",
    "            loss += n_loss\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "        \n",
    "    def _compute_dqn_loss(\n",
    "        self, \n",
    "        samples: Dict[str, np.ndarray], \n",
    "        gamma: float\n",
    "    ) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).max(\n",
    "            dim=1, keepdim=True\n",
    "        )[0].detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 2000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 2000x500 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video /workspaces/rainbow-is-all-you-need/videos/n_step_learning/rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video /workspaces/rainbow-is-all-you-need/videos/n_step_learning/rl-video-episode-0.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                               "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready /workspaces/rainbow-is-all-you-need/videos/n_step_learning/rl-video-episode-0.mp4\n",
      "score:  200.0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/n_step_learning\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/n_step_learning/rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
